using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("UberText")]
	public class UberText : MonoBehaviour
	{
		[Attribute38("UberText.LocalizationSettings")]
		public class LocalizationSettings : MonoClass
		{
			[Attribute38("UberText.LocalizationSettings.LocaleAdjustment")]
			public class LocaleAdjustment : MonoClass
			{
				public Locale m_Locale => method_2<Locale>("m_Locale");

				public float m_LineSpaceModifier => method_2<float>("m_LineSpaceModifier");

				public float m_SingleLineAdjustment => method_2<float>("m_SingleLineAdjustment");

				public float m_Width => method_2<float>("m_Width");

				public float m_Height => method_2<float>("m_Height");

				public float m_FontSizeModifier => method_2<float>("m_FontSizeModifier");

				public float m_UnderwearWidth => method_2<float>("m_UnderwearWidth");

				public float m_UnderwearHeight => method_2<float>("m_UnderwearHeight");

				public float m_OutlineModifier => method_2<float>("m_OutlineModifier");

				public float m_UnboundCharacterSizeModifier => method_2<float>("m_UnboundCharacterSizeModifier");

				public float m_ResizeToFitWidthModifier => method_2<float>("m_ResizeToFitWidthModifier");

				public Vector3 m_PositionOffset => method_2<Vector3>("m_PositionOffset");

				public LocaleAdjustment(IntPtr address, string className)
					: base(address, className)
				{
				}

				public LocaleAdjustment(IntPtr address)
					: this(address, "LocaleAdjustment")
				{
				}
			}

			public List<LocaleAdjustment> m_LocaleAdjustments => method_3<Class271<LocaleAdjustment>>("m_LocaleAdjustments")?.method_25();

			public LocalizationSettings(IntPtr address, string className)
				: base(address, className)
			{
			}

			public LocalizationSettings(IntPtr address)
				: this(address, "LocalizationSettings")
			{
			}

			public bool HasLocale(Locale locale)
			{
				return method_11<bool>("HasLocale", new object[1] { locale });
			}

			public LocaleAdjustment GetLocale(Locale locale)
			{
				return method_14<LocaleAdjustment>("GetLocale", new object[1] { locale });
			}

			public LocaleAdjustment AddLocale(Locale locale)
			{
				return method_14<LocaleAdjustment>("AddLocale", new object[1] { locale });
			}

			public void RemoveLocale(Locale locale)
			{
				method_8("RemoveLocale", locale);
			}
		}

		[Attribute38("UberText.CachedTextKeyData")]
		public class CachedTextKeyData : MonoClass
		{
			public string m_Text => method_4("m_Text");

			public int m_FontSize => method_2<int>("m_FontSize");

			public float m_CharSize => method_2<float>("m_CharSize");

			public float m_Width => method_2<float>("m_Width");

			public float m_Height => method_2<float>("m_Height");

			public float m_LineSpacing => method_2<float>("m_LineSpacing");

			public CachedTextKeyData(IntPtr address, string className)
				: base(address, className)
			{
			}

			public CachedTextKeyData(IntPtr address)
				: this(address, "CachedTextKeyData")
			{
			}

			public new int GetHashCode()
			{
				return method_11<int>("GetHashCode", Array.Empty<object>());
			}
		}

		[Attribute38("UberText.CachedTextValues")]
		public class CachedTextValues : MonoClass
		{
			public string m_Text => method_4("m_Text");

			public float m_CharSize => method_2<float>("m_CharSize");

			public int m_OriginalTextHash => method_2<int>("m_OriginalTextHash");

			public CachedTextValues(IntPtr address, string className)
				: base(address, className)
			{
			}

			public CachedTextValues(IntPtr address)
				: this(address, "CachedTextValues")
			{
			}
		}

		public enum AlignmentOptions
		{
			Left,
			Center,
			Right
		}

		public enum AnchorOptions
		{
			Upper,
			Middle,
			Lower
		}

		public enum TextRenderMaterial
		{
			Text,
			Bold,
			Outline,
			InlineImages
		}

		public enum Fonts
		{
			BlizzardGlobal,
			Belwe,
			BelweOutline,
			FranklinGothic
		}

		public enum ThaiGlyphType
		{
			BASE,
			BASE_ASCENDER,
			BASE_DESCENDER,
			TONE_MARK,
			UPPER,
			LOWER
		}

		public static int CACHE_FILE_VERSION_TEMP => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "UberText", "CACHE_FILE_VERSION_TEMP");

		public static int CACHE_FILE_MAX_SIZE => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "UberText", "CACHE_FILE_MAX_SIZE");

		public static string FONT_NAME_BLIZZARD_GLOBAL => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "UberText", "FONT_NAME_BLIZZARD_GLOBAL");

		public static string FONT_NAME_BELWE_OUTLINE => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "UberText", "FONT_NAME_BELWE_OUTLINE");

		public static string FONT_NAME_BELWE => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "UberText", "FONT_NAME_BELWE");

		public static string FONT_NAME_FRANKLIN_GOTHIC => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "UberText", "FONT_NAME_FRANKLIN_GOTHIC");

		public string TEXT_SHADER_NAME => method_4("TEXT_SHADER_NAME");

		public string PLANE_SHADER_NAME => method_4("PLANE_SHADER_NAME");

		public string BOLD_SHADER_NAME => method_4("BOLD_SHADER_NAME");

		public string BOLD_OUTLINE_TEXT_SHADER_NAME => method_4("BOLD_OUTLINE_TEXT_SHADER_NAME");

		public string OUTLINE_TEXT_SHADER_NAME => method_4("OUTLINE_TEXT_SHADER_NAME");

		public string OUTLINE_TEXT_2PASS_SHADER_NAME => method_4("OUTLINE_TEXT_2PASS_SHADER_NAME");

		public string OUTLINE_NO_VERT_COLOR_TEXT_SHADER_NAME => method_4("OUTLINE_NO_VERT_COLOR_TEXT_SHADER_NAME");

		public string OUTLINE_NO_VERT_COLOR_TEXT_2PASS_SHADER_NAME => method_4("OUTLINE_NO_VERT_COLOR_TEXT_2PASS_SHADER_NAME");

		public string TEXT_ANTIALAISING_SHADER_NAME => method_4("TEXT_ANTIALAISING_SHADER_NAME");

		public string INLINE_IMAGE_SHADER_NAME => method_4("INLINE_IMAGE_SHADER_NAME");

		public string SHADOW_SHADER_NAME => method_4("SHADOW_SHADER_NAME");

		public static float CHARACTER_SIZE_SCALE => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "UberText", "CHARACTER_SIZE_SCALE");

		public static float BOLD_MAX_SIZE => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "UberText", "BOLD_MAX_SIZE");

		public static int MAX_REDUCE_TEXT_COUNT => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "UberText", "MAX_REDUCE_TEXT_COUNT");

		public string m_Text => method_4("m_Text");

		public bool m_GameStringLookup => method_2<bool>("m_GameStringLookup");

		public bool m_UseEditorText => method_2<bool>("m_UseEditorText");

		public float m_Width => method_2<float>("m_Width");

		public float m_Height => method_2<float>("m_Height");

		public float m_LineSpacing => method_2<float>("m_LineSpacing");

		public int m_FontSize => method_2<int>("m_FontSize");

		public int m_MinFontSize => method_2<int>("m_MinFontSize");

		public float m_CharacterSize => method_2<float>("m_CharacterSize");

		public float m_MinCharacterSize => method_2<float>("m_MinCharacterSize");

		public bool m_RichText => method_2<bool>("m_RichText");

		public Color m_TextColor => method_2<Color>("m_TextColor");

		public float m_BoldSize => method_2<float>("m_BoldSize");

		public bool m_WordWrap => method_2<bool>("m_WordWrap");

		public bool m_ForceWrapLargeWords => method_2<bool>("m_ForceWrapLargeWords");

		public bool m_ResizeToFit => method_2<bool>("m_ResizeToFit");

		public bool m_Underwear => method_2<bool>("m_Underwear");

		public bool m_UnderwearFlip => method_2<bool>("m_UnderwearFlip");

		public float m_UnderwearWidth => method_2<float>("m_UnderwearWidth");

		public float m_UnderwearHeight => method_2<float>("m_UnderwearHeight");

		public AlignmentOptions m_Alignment => method_2<AlignmentOptions>("m_Alignment");

		public AnchorOptions m_Anchor => method_2<AnchorOptions>("m_Anchor");

		public bool m_RenderToTexture => method_2<bool>("m_RenderToTexture");

		public GameObject m_RenderOnObject => method_3<GameObject>("m_RenderOnObject");

		public int m_Resolution => method_2<int>("m_Resolution");

		public bool m_Outline => method_2<bool>("m_Outline");

		public float m_OutlineSize => method_2<float>("m_OutlineSize");

		public Color m_OutlineColor => method_2<Color>("m_OutlineColor");

		public bool m_AntiAlias => method_2<bool>("m_AntiAlias");

		public float m_AntiAliasAmount => method_2<float>("m_AntiAliasAmount");

		public float m_AntiAliasEdge => method_2<float>("m_AntiAliasEdge");

		public bool m_Shadow => method_2<bool>("m_Shadow");

		public float m_ShadowOffset => method_2<float>("m_ShadowOffset");

		public float m_ShadowDepthOffset => method_2<float>("m_ShadowDepthOffset");

		public Color m_ShadowColor => method_2<Color>("m_ShadowColor");

		public float m_ShadowBlur => method_2<float>("m_ShadowBlur");

		public int m_ShadowRenderQueueOffset => method_2<int>("m_ShadowRenderQueueOffset");

		public int m_RenderQueue => method_2<int>("m_RenderQueue");

		public float m_AmbientLightBlend => method_2<float>("m_AmbientLightBlend");

		public Color m_GradientUpperColor => method_2<Color>("m_GradientUpperColor");

		public Color m_GradientLowerColor => method_2<Color>("m_GradientLowerColor");

		public bool m_Cache => method_2<bool>("m_Cache");

		public LocalizationSettings m_LocalizedSettings => method_3<LocalizationSettings>("m_LocalizedSettings");

		public bool m_isFontDefLoaded => method_2<bool>("m_isFontDefLoaded");

		public Texture m_FontTexture => method_3<Texture>("m_FontTexture");

		public float m_LineSpaceModifier => method_2<float>("m_LineSpaceModifier");

		public float m_SingleLineAdjustment => method_2<float>("m_SingleLineAdjustment");

		public float m_FontSizeModifier => method_2<float>("m_FontSizeModifier");

		public float m_CharacterSizeModifier => method_2<float>("m_CharacterSizeModifier");

		public float m_UnboundCharacterSizeModifier => method_2<float>("m_UnboundCharacterSizeModifier");

		public float m_OutlineModifier => method_2<float>("m_OutlineModifier");

		public float m_WorldWidth => method_2<float>("m_WorldWidth");

		public float m_WorldHeight => method_2<float>("m_WorldHeight");

		public bool m_updated => method_2<bool>("m_updated");

		public string m_PreviousText => method_4("m_PreviousText");

		public List<string> m_Words => method_3<Class249>("m_Words")?.method_25();

		public TextMesh m_TextMesh => method_3<TextMesh>("m_TextMesh");

		public GameObject m_TextMeshGameObject => m_UberTextRendering.m_textMeshGameObject;

		public Material TextMeshBaseMaterial => method_3<Material>("TextMeshBaseMaterial");

		public Camera m_Camera => method_3<Camera>("m_Camera");

		public GameObject m_CameraGO => method_3<GameObject>("m_CameraGO");

		public Mesh m_PlaneMesh => method_3<Mesh>("m_PlaneMesh");

		public GameObject m_PlaneGameObject => method_3<GameObject>("m_PlaneGameObject");

		public float m_PreviousPlaneWidth => method_2<float>("m_PreviousPlaneWidth");

		public float m_PreviousPlaneHeight => method_2<float>("m_PreviousPlaneHeight");

		public int m_PreviousResolution => method_2<int>("m_PreviousResolution");

		public int m_LineCount => method_2<int>("m_LineCount");

		public GameObject m_ShadowPlaneGameObject => method_3<GameObject>("m_ShadowPlaneGameObject");

		public Vector2 m_PreviousTexelSize => method_2<Vector2>("m_PreviousTexelSize");

		public int m_OrgRenderQueue => method_2<int>("m_OrgRenderQueue");

		public bool m_Ellipsized => method_2<bool>("m_Ellipsized");

		public int m_CacheHash => method_2<int>("m_CacheHash");

		public bool m_Hidden => method_2<bool>("m_Hidden");

		public bool m_TextSet => method_2<bool>("m_TextSet");

		public Bounds m_UnderwearLeftBounds => method_2<Bounds>("m_UnderwearLeftBounds");

		public Bounds m_UnderwearRightBounds => method_2<Bounds>("m_UnderwearRightBounds");

		public static bool s_InlineImageTextureLoaded => MonoClass.smethod_6<bool>(TritonHs.MainAssemblyPath, "", "UberText", "s_InlineImageTextureLoaded");

		public static float s_offset => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "UberText", "s_offset");

		public float m_Offset => method_2<float>("m_Offset");

		public List<Vector2> PLANE_UVS => method_3<Class250<Vector2>>("PLANE_UVS")?.method_25();

		public List<Vector3> PLANE_NORMALS => method_3<Class250<Vector3>>("PLANE_NORMALS")?.method_25();

		public List<int> PLANE_TRIANGLES => method_3<Class250<int>>("PLANE_TRIANGLES")?.method_25();

		public static bool s_disableCache => MonoClass.smethod_6<bool>(TritonHs.MainAssemblyPath, "", "UberText", "s_disableCache");

		public static int RENDER_LAYER => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "UberText", "RENDER_LAYER");

		public static int RENDER_LAYER_BIT => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "UberText", "RENDER_LAYER_BIT");

		public Material m_TextMaterial => method_3<Material>("m_TextMaterial");

		public Material m_PlaneMaterial => method_3<Material>("m_PlaneMaterial");

		public Material m_BoldMaterial => method_3<Material>("m_BoldMaterial");

		public Material m_OutlineTextMaterial => method_3<Material>("m_OutlineTextMaterial");

		public Material m_TextAntialiasingMaterial => method_3<Material>("m_TextAntialiasingMaterial");

		public Material m_ShadowMaterial => method_3<Material>("m_ShadowMaterial");

		public Material m_InlineImageMaterial => method_3<Material>("m_InlineImageMaterial");

		public static List<char> STRIP_CHARS_INDEX_OF_ANY => MonoClass.smethod_7<Class250<char>>(TritonHs.MainAssemblyPath, "", "UberText", "STRIP_CHARS_INDEX_OF_ANY")?.method_25();

		public float Offset => method_11<float>("get_Offset", Array.Empty<object>());

		public Material TextMaterial => method_14<Material>("get_TextMaterial", Array.Empty<object>());

		public Material PlaneMaterial => method_14<Material>("get_PlaneMaterial", Array.Empty<object>());

		public Material BoldMaterial => method_14<Material>("get_BoldMaterial", Array.Empty<object>());

		public Material OutlineTextMaterial => method_14<Material>("get_OutlineTextMaterial", Array.Empty<object>());

		public Material TextAntialiasingMaterial => method_14<Material>("get_TextAntialiasingMaterial", Array.Empty<object>());

		public Material ShadowMaterial => method_14<Material>("get_ShadowMaterial", Array.Empty<object>());

		public Material InlineImageMaterial => method_14<Material>("get_InlineImageMaterial", Array.Empty<object>());

		public string Text => method_13("get_Text");

		public bool GameStringLookup => method_11<bool>("get_GameStringLookup", Array.Empty<object>());

		public bool UseEditorText => method_11<bool>("get_UseEditorText", Array.Empty<object>());

		public bool Cache => method_11<bool>("get_Cache", Array.Empty<object>());

		public float Width => method_11<float>("get_Width", Array.Empty<object>());

		public float Height => method_11<float>("get_Height", Array.Empty<object>());

		public float LineSpacing => method_11<float>("get_LineSpacing", Array.Empty<object>());

		public int FontSize => method_11<int>("get_FontSize", Array.Empty<object>());

		public int MinFontSize => method_11<int>("get_MinFontSize", Array.Empty<object>());

		public float CharacterSize => method_11<float>("get_CharacterSize", Array.Empty<object>());

		public float MinCharacterSize => method_11<float>("get_MinCharacterSize", Array.Empty<object>());

		public bool RichText => method_11<bool>("get_RichText", Array.Empty<object>());

		public Color TextColor => method_11<Color>("get_TextColor", Array.Empty<object>());

		public float TextAlpha => method_11<float>("get_TextAlpha", Array.Empty<object>());

		public float BoldSize => method_11<float>("get_BoldSize", Array.Empty<object>());

		public bool WordWrap => method_11<bool>("get_WordWrap", Array.Empty<object>());

		public bool ForceWrapLargeWords => method_11<bool>("get_ForceWrapLargeWords", Array.Empty<object>());

		public bool ResizeToFit => method_11<bool>("get_ResizeToFit", Array.Empty<object>());

		public bool Underwear => method_11<bool>("get_Underwear", Array.Empty<object>());

		public bool UnderwearFlip => method_11<bool>("get_UnderwearFlip", Array.Empty<object>());

		public float UnderwearWidth => method_11<float>("get_UnderwearWidth", Array.Empty<object>());

		public float UnderwearHeight => method_11<float>("get_UnderwearHeight", Array.Empty<object>());

		public AlignmentOptions Alignment => method_11<AlignmentOptions>("get_Alignment", Array.Empty<object>());

		public AnchorOptions Anchor => method_11<AnchorOptions>("get_Anchor", Array.Empty<object>());

		public bool RenderToTexture => method_11<bool>("get_RenderToTexture", Array.Empty<object>());

		public GameObject RenderOnObject => method_14<GameObject>("get_RenderOnObject", Array.Empty<object>());

		public int TextureResolution => method_11<int>("get_TextureResolution", Array.Empty<object>());

		public bool Outline => method_11<bool>("get_Outline", Array.Empty<object>());

		public float OutlineSize => method_11<float>("get_OutlineSize", Array.Empty<object>());

		public Color OutlineColor => method_11<Color>("get_OutlineColor", Array.Empty<object>());

		public float OutlineAlpha => method_11<float>("get_OutlineAlpha", Array.Empty<object>());

		public bool AntiAlias => method_11<bool>("get_AntiAlias", Array.Empty<object>());

		public float AntiAliasAmount => method_11<float>("get_AntiAliasAmount", Array.Empty<object>());

		public LocalizationSettings LocalizeSettings => method_14<LocalizationSettings>("get_LocalizeSettings", Array.Empty<object>());

		public float AntiAliasEdge => method_11<float>("get_AntiAliasEdge", Array.Empty<object>());

		public bool Shadow => method_11<bool>("get_Shadow", Array.Empty<object>());

		public float ShadowOffset => method_11<float>("get_ShadowOffset", Array.Empty<object>());

		public float ShadowDepthOffset => method_11<float>("get_ShadowDepthOffset", Array.Empty<object>());

		public float ShadowBlur => method_11<float>("get_ShadowBlur", Array.Empty<object>());

		public Color ShadowColor => method_11<Color>("get_ShadowColor", Array.Empty<object>());

		public float ShadowAlpha => method_11<float>("get_ShadowAlpha", Array.Empty<object>());

		public int ShadowRenderQueueOffset => method_11<int>("get_ShadowRenderQueueOffset", Array.Empty<object>());

		public int RenderQueue => method_11<int>("get_RenderQueue", Array.Empty<object>());

		public float AmbientLightBlend => method_11<float>("get_AmbientLightBlend", Array.Empty<object>());

		public Color GradientUpperColor => method_11<Color>("get_GradientUpperColor", Array.Empty<object>());

		public float GradientUpperAlpha => method_11<float>("get_GradientUpperAlpha", Array.Empty<object>());

		public Color GradientLowerColor => method_11<Color>("get_GradientLowerColor", Array.Empty<object>());

		public float GradientLowerAlpha => method_11<float>("get_GradientLowerAlpha", Array.Empty<object>());

		public UberTextRendering m_UberTextRendering => method_3<UberTextRendering>("m_UberTextRendering");

		public UberText(IntPtr address, string className)
			: base(address, className)
		{
		}

		public UberText(IntPtr address)
			: this(address, "UberText")
		{
		}

		public static List<UberText> EnableAllTextInObject(GameObject obj, bool enable)
		{
			return MonoClass.smethod_15<Class251<UberText>>(TritonHs.MainAssemblyPath, "", "UberText", "EnableAllTextInObject", new object[2] { obj, enable })?.method_25();
		}

		public static void RebuildAllUberText()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "UberText", "RebuildAllUberText");
		}

		public static void DisableCache()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "UberText", "DisableCache");
		}

		public static Vector3 GetWorldScale(Transform xform)
		{
			return MonoClass.smethod_14<Vector3>(TritonHs.MainAssemblyPath, "", "UberText", "GetWorldScale", new object[1] { xform });
		}

		public static string RemoveLineBreakTagsHardSpace(string text)
		{
			return MonoClass.smethod_12(TritonHs.MainAssemblyPath, "", "UberText", "RemoveLineBreakTagsHardSpace", text);
		}

		public static bool IsValidSquareBracketTag(char ch)
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "UberText", "IsValidSquareBracketTag", new object[1] { ch });
		}

		public static bool IsWhitespaceOrUnderscore(char ch)
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "UberText", "IsWhitespaceOrUnderscore", new object[1] { ch });
		}

		public static string RemoveMarkupAndCollapseWhitespaces(string text)
		{
			return MonoClass.smethod_12(TritonHs.MainAssemblyPath, "", "UberText", "RemoveMarkupAndCollapseWhitespaces", text);
		}

		public static int LineCount(string s)
		{
			return MonoClass.smethod_14<int>(TritonHs.MainAssemblyPath, "", "UberText", "LineCount", new object[1] { s });
		}

		public static void DeleteOldCacheFiles()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "UberText", "DeleteOldCacheFiles");
		}

		public static string GetCacheFolderPath()
		{
			return MonoClass.smethod_12(TritonHs.MainAssemblyPath, "", "UberText", "GetCacheFolderPath");
		}

		public static string GetCacheFilePath()
		{
			return MonoClass.smethod_12(TritonHs.MainAssemblyPath, "", "UberText", "GetCacheFilePath");
		}

		public static void CreateCacheFolder()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "UberText", "CreateCacheFolder");
		}

		public static void StoreCachedData()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "UberText", "StoreCachedData");
		}

		public static void LoadCachedData()
		{
			MonoClass.smethod_17(TritonHs.MainAssemblyPath, "", "UberText", "LoadCachedData");
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void Start()
		{
			method_8("Start");
		}

		public void Update()
		{
			method_8("Update");
		}

		public void OnDisable()
		{
			method_8("OnDisable");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public void OnEnable()
		{
			method_8("OnEnable");
		}

		public void OnDrawGizmos()
		{
			method_8("OnDrawGizmos");
		}

		public void OnDrawGizmosSelected()
		{
			method_8("OnDrawGizmosSelected");
		}

		public void Show()
		{
			method_8("Show");
		}

		public void Hide()
		{
			method_8("Hide");
		}

		public bool isHidden()
		{
			return method_11<bool>("isHidden", Array.Empty<object>());
		}

		public void EditorAwake()
		{
			method_8("EditorAwake");
		}

		public bool IsDone()
		{
			return method_11<bool>("IsDone", Array.Empty<object>());
		}

		public void UpdateText()
		{
			method_8("UpdateText");
		}

		public void UpdateNow()
		{
			method_8("UpdateNow");
		}

		public Bounds GetBounds()
		{
			return method_11<Bounds>("GetBounds", Array.Empty<object>());
		}

		public Bounds GetTextBounds()
		{
			return method_11<Bounds>("GetTextBounds", Array.Empty<object>());
		}

		public Bounds GetTextWorldSpaceBounds()
		{
			return method_11<Bounds>("GetTextWorldSpaceBounds", Array.Empty<object>());
		}

		public Vector3 GetLocalizationPositionOffset()
		{
			return method_11<Vector3>("GetLocalizationPositionOffset", Array.Empty<object>());
		}

		public int GetLineCount()
		{
			return method_11<int>("GetLineCount", Array.Empty<object>());
		}

		public float GetActualCharacterSize()
		{
			return method_11<float>("GetActualCharacterSize", Array.Empty<object>());
		}

		public bool IsMultiLine()
		{
			return method_11<bool>("IsMultiLine", Array.Empty<object>());
		}

		public bool IsEllipsized()
		{
			return method_11<bool>("IsEllipsized", Array.Empty<object>());
		}

		public void SetGameStringText(string gameStringTag)
		{
			method_8("SetGameStringText", gameStringTag);
		}

		public LocalizationSettings.LocaleAdjustment AddLocaleAdjustment(Locale locale)
		{
			return method_14<LocalizationSettings.LocaleAdjustment>("AddLocaleAdjustment", new object[1] { locale });
		}

		public LocalizationSettings.LocaleAdjustment GetLocaleAdjustment(Locale locale)
		{
			return method_14<LocalizationSettings.LocaleAdjustment>("GetLocaleAdjustment", new object[1] { locale });
		}

		public void RemoveLocaleAdjustment(Locale locale)
		{
			method_8("RemoveLocaleAdjustment", locale);
		}

		public LocalizationSettings GetAllLocalizationSettings()
		{
			return method_14<LocalizationSettings>("GetAllLocalizationSettings", Array.Empty<object>());
		}

		public void SetFontWithoutLocalization(FontDef fontDef)
		{
			method_8("SetFontWithoutLocalization", fontDef);
		}

		public string GetProcessedText()
		{
			return method_13("GetProcessedText");
		}

		public void RenderText()
		{
			method_8("RenderText");
		}

		public void UpdateTextMesh()
		{
			method_8("UpdateTextMesh");
		}

		public void UpdateColor()
		{
			method_8("UpdateColor");
		}

		public void UpdateFontTextures()
		{
			method_8("UpdateFontTextures");
		}

		public void UpdateLayers()
		{
			method_8("UpdateLayers");
		}

		public void UpdateRenderQueue()
		{
			method_8("UpdateRenderQueue");
		}

		public void UpdateTexelSize()
		{
			method_8("UpdateTexelSize");
		}

		public void CreateTextMesh()
		{
			method_8("CreateTextMesh");
		}

		public void SetFontSize(int fontSize)
		{
			method_8("SetFontSize", fontSize);
		}

		public float GetWidth()
		{
			return method_11<float>("GetWidth", Array.Empty<object>());
		}

		public float GetHeight()
		{
			return method_11<float>("GetHeight", Array.Empty<object>());
		}

		public void SetLineSpacing(float lineSpacing)
		{
			method_8("SetLineSpacing", lineSpacing);
		}

		public void SetActualCharacterSize(float characterSize)
		{
			method_8("SetActualCharacterSize", characterSize);
		}

		public void SetText(string text)
		{
			method_8("SetText", text);
		}

		public void SetRichText(bool richText)
		{
			method_8("SetRichText", richText);
		}

		public Texture GetFontTexture()
		{
			return method_14<Texture>("GetFontTexture", Array.Empty<object>());
		}

		public void DestroyTextMesh()
		{
			method_8("DestroyTextMesh");
		}

		public void CreateEditorRoot()
		{
			method_8("CreateEditorRoot");
		}

		public void CreateCamera()
		{
			method_8("CreateCamera");
		}

		public void DestroyCamera()
		{
			method_8("DestroyCamera");
		}

		public void CreateTexture()
		{
			method_8("CreateTexture");
		}

		public void DestroyTexture()
		{
			method_8("DestroyTexture");
		}

		public void CreateRenderPlane()
		{
			method_8("CreateRenderPlane");
		}

		public void DestroyRenderPlane()
		{
			method_8("DestroyRenderPlane");
		}

		public void SetupRenderOnObject()
		{
			method_8("SetupRenderOnObject");
		}

		public void ResizeTextToFit(string text)
		{
			method_8("ResizeTextToFit", text);
		}

		public void ReduceText(string text, int step, int newSize)
		{
			method_8("ReduceText", text, step, newSize);
		}

		public float Measure_IntraLine_Height()
		{
			return method_11<float>("Measure_IntraLine_Height", Array.Empty<object>());
		}

		public void ReduceText_CharSize(string text)
		{
			method_8("ReduceText_CharSize", text);
		}

		public void SetupForRender()
		{
			method_8("SetupForRender");
		}

		public string WordWrapString(string text, float width)
		{
			return method_12("WordWrapString", new Class276.Enum20[2]
			{
				Class276.Enum20.String,
				Class276.Enum20.R4
			}, text, width);
		}

		public string WordWrapString(string text, float width, bool ellipsis)
		{
			return method_12("WordWrapString", new Class276.Enum20[3]
			{
				Class276.Enum20.String,
				Class276.Enum20.R4,
				Class276.Enum20.Boolean
			}, text, width, ellipsis);
		}

		public string ProcessText(string text)
		{
			return method_13("ProcessText", text);
		}

		public string LocalizationFixes(string text)
		{
			return method_13("LocalizationFixes", text);
		}

		public void ShadowRender()
		{
			method_8("ShadowRender");
		}

		public void DestroyShadow()
		{
			method_8("DestroyShadow");
		}

		public void OutlineRender()
		{
			method_8("OutlineRender");
		}

		public void AntiAliasRender()
		{
			method_8("AntiAliasRender");
		}

		public void Bold()
		{
			method_8("Bold");
		}

		public string InlineImage(string tag)
		{
			return method_13("InlineImage", tag);
		}

		public int TextEffectsMaterial(TextRenderMaterial materialKey, Material material)
		{
			return method_11<int>("TextEffectsMaterial", new object[2] { materialKey, material });
		}

		public void SetManaTexture(AssetReference assetRef, object asset, object callbackData)
		{
			method_8("SetManaTexture", assetRef, asset, callbackData);
		}

		public void UpdateEditorText()
		{
			method_8("UpdateEditorText");
		}

		public Vector2 GetWorldWidthAndHight()
		{
			return method_11<Vector2>("GetWorldWidthAndHight", Array.Empty<object>());
		}

		public Vector3 GetLossyWorldScale(Transform xform)
		{
			return method_11<Vector3>("GetLossyWorldScale", new object[1] { xform });
		}

		public void FindSupportedTextureFormat()
		{
			method_8("FindSupportedTextureFormat");
		}

		public Vector2 CalcTextureSize()
		{
			return method_11<Vector2>("CalcTextureSize", Array.Empty<object>());
		}

		public string RemoveTagsFromWord(string word)
		{
			return method_13("RemoveTagsFromWord", word);
		}

		public void DestroyChildren()
		{
			method_8("DestroyChildren");
		}

		public void CleanUp()
		{
			method_8("CleanUp");
		}

		public List<string> BreakStringIntoWords(string text)
		{
			return method_14<Class249>("BreakStringIntoWords", new object[1] { text })?.method_25();
		}

		public Vector2 TexelSize(Texture texture)
		{
			return method_11<Vector2>("TexelSize", new object[1] { texture });
		}

		public bool CanWrapBetween(int lastChar, int wideChar, int nextChar)
		{
			return method_11<bool>("CanWrapBetween", new object[3] { lastChar, wideChar, nextChar });
		}

		public string FixThai(string text)
		{
			return method_13("FixThai", text);
		}
	}
}
